Magnum One

home *** CD-ROM | disk | FTP | other *** search

/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d11 / frasrc14.arc / CALCMAND.ASM < prev next >

Wrap

Assembly Source File | 1990-08-02 | 34KB | 1,089 lines

; CALCMAND.ASM - Mandelbrot/Julia Set calculation Routines ; The routines in this code perform Mandelbrot and Julia set ; calculations using 32-bit integer math as opposed to the ; "traditional" floating-point approach. ; This code relies on several tricks to run as quickly as it does. ; One can fake floating point arithmetic by using integer ; arithmetic and keeping track of the implied decimal point ; if things are reasonable -- and in this case, they are. ; I replaced code that looked like: z = x*y with code that ; looks like: ; ix = x * ifudge (outside the loops) ; iy = y * ifudge ; .... ; iz = (ix * iy) / ifudge (inside the loops) ; (and keep remembering that all the integers are "ifudged" bigger) ; The 386 has native 32-bit integer arithmetic, and (briefly) keeps ; 64-bit values around after 32-bit multiplies. If the result is ; divided down right away, you've got 64-bit arithmetic. You just ; have to ensure that the result after the divide is <= 32 bits long. ; CPUs predating the 386 have to emulate 32-bit arithmetic using ; 16-bit arithmetic, which is significantly slower. ; Dividing is slow -- but shifting is fast, and we can select our ; "fudge factor" to be a power of two, permitting us to use that ; method instead. In addition, the 386 can perform 32-bit wide ; shifting -- and even 64-bit shifts with the following logic: ; shdr eax,edx,cl ; shr edx,cl ; so we make sure that our "fudge factor" is a power of 2 and shift ; it down that way. ; Bert Tyler ; required for compatibility if Turbo ASM IFDEF ??version MASM51 QUIRKS ENDIF .MODEL medium,c DGROUP group _DATA,_DATA2 .8086 ; these must NOT be in any segment!! ; this get's rid of TURBO-C fixup errors extrn asmdotwrite:far ; this routine is in 'general.asm' extrn asmvideocleanup:far ; this routine is in 'general.asm' extrn keypressed:far ; this routine is in 'general.asm' extrn getakey:far ; this routine is in 'general.asm' extrn iplot_orbit:far ; this routine is in 'calcfrac.c' extrn scrub_orbit:far ; this routine is in 'calcfrac.c' extrn intpotential:far ; this routine is in 'calcfrac.c' extrn lx0:dword, ly0:dword ; arrays of (dword) increment values extrn lx1:dword, ly1:dword ; arrays of (dword) increment values _DATA2 segment DWORD PUBLIC 'DATA' FUDGEFACTOR equ 29 ; default (non-potential) fudgefactor FUDGEFACTOR2 equ 24 ; potential algoithm variant ; ************************ External variables ***************************** extrn fractype:word ; == 0 if Mandelbrot set, else Julia extrn numpasses:word ; == 0 if single-pass, 1 if 2-pass extrn passnum:word ; == 1 if 1st pass of 2, 2 if final pass extrn inside:word ; "inside" color, normally 1 (blue) extrn creal:dword, cimag:dword ; Julia Set Constant extrn delmin:dword ; min increment - precision required extrn xdots:word, ydots:word ; number of dots across and down extrn maxit:word, colors:word ; maximum iterations, colors extrn bitshift:word ; number of bits to shift extrn lm:dword ; magnitude bailout limit extrn potflag:word ; "continuous potential" flag extrn LogFlag:word ; non-zero of logarithmic palettes extrn LogTable:dword ; far pointer to log palette table extrn ixstart:word, ixstop:word ; start, stop here extrn iystart:word, iystop:word ; start, stop here extrn yybegin:word ; start pass 1 of 2 here extrn xxstart:word, xxstop:word ; window (!= ix... if symmetry) extrn yystart:word, yystop:word ; window (!= iy... if symmetry) extrn row:word, col:word ; current pixel to calc extrn calcmode:word ; 0 if 1 or 2 pass, ; 1 if ssg/btm initialization call, ; 2 if ssg/btm 1pixel, reset periodicity ; 3 if ssg/btm 1pixel, no reset extrn cpu:word ; cpu type: 86, 186, 286, or 386 extrn andcolor:word ; "and" value used for color selection extrn show_orbit:word ; "show-orbit" flag extrn orbit_ptr:word ; "orbit pointer" flag extrn symmetry:word ; "Symmetry" flag extrn debugflag:word ; for debugging purposes only ; ************************ Internal variables ***************************** align 4 x dd 0 ; temp value: x y dd 0 ; temp value: y a dd 0 ; temp value: a b dd 0 ; temp value: b xx dd 0 ; temp value: x-squared yy dd 0 ; temp value: y-squared xxmyy dd 0 ; temp value: x-squared minus y-squared sign db 0 ; sign calue: used by 16-bit multiplies period db 0 ; periodicity, if in the lake color db 0 ; the color to set a pixel align 2 temp dw 4 dup (0) ; temp value: used by 16-bit multiplies k dw 0 ; local counter kbdcount dw 0 ; keyboard counter kbdflag dw 0 ; keyboard hit flag: 0 if no, 1 if yes oldcolor dw 0 ; == "old" color savedand dw 0 ; AND value for periodicity checks savedincr dw 0 ; flag for incrementing AND value align 4 savedmask dd 0 ; saved values mask savedx dd 0 ; saved values of X and Y iterations savedy dd 0 ; (for periodicity checks) _DATA2 ends .CODE ; ***************** Function calcmandasm() ********************************** public calcmandasm calcmandasm proc push di push si push es ; save the original ES value mov ax,0a000h ; EGA, VGA, MCGA starts here mov es,ax ; save it here during this routine mov kbdflag,0 ; initialize keyboard int flag: nope cmp calcmode,2 ; 1pixel call? jge short dopixel ; yup, skip initialization, got row/col mov ax,word ptr delmin ; compute the periodicity check value mov dx,word ptr delmin+2 ; load smallest of delx, dely mov word ptr savedmask,0 ; starting value for savedmask mov word ptr savedmask+2,0c000h ; ... maskloop: sar word ptr savedmask+2,1 ; shift savedmask right one bit rcr word ptr savedmask,1 ; ... shl ax,1 ; now shift delmin left one bit rcl dx,1 ; ... jnc maskloop ; loop if no one bits hit yet mov kbdcount,100 ; init keyboard ctr high for solidguess cmp calcmode,1 ; do initialization only? jne passstart jmp wedone passstart: mov ax,yybegin ; initialize outer loop mov row,ax ; ... yloop: ; for (y = iystart; y <= iystop; y++) mov ax,ixstart ; initialize inner loop mov col,ax ; ... dopixel: cmp calcmode,3 ; 1pixel, no periodicity reset? je short xloop ; inherit oldcolor from prior invocation mov oldcolor,0 ; set (dummy) flag: old color was high cmp maxit,250 ; over 250 iterations max? jbe short xloop ; nope. mov bx,maxit ; yup. reset oldcolor sub bx,250 ; to maxit-250. mov oldcolor,bx ; (avoids slowness at 32000 iters) xloop: ; for (x = ixstart; x <= ixstop; x++) push es ; save this for a tad mov cx,col ; pull lx0 value out of the array shl cx,1 ; convert to double-word pointer shl cx,1 ; ... les bx,lx0 add bx,cx mov ax,word ptr es:0[bx] ; here it is! mov dx,word ptr es:2[bx] ; ... mov word ptr a,ax ; save it for later mov word ptr a+2,dx ; ... les bx,ly1 ; delta y per x add bx,cx mov ax,word ptr es:0[bx] ; here it is! mov dx,word ptr es:2[bx] ; ... mov word ptr b,ax ; save it for later mov word ptr b+2,dx ; ... mov cx,row ; pull ly0 value out of the array shl cx,1 ; convert to double-word pointer shl cx,1 ; ... les bx,ly0 add bx,cx mov ax,word ptr es:0[bx] ; here it is! mov dx,word ptr es:2[bx] ; ... add word ptr b,ax ; save it for later adc word ptr b+2,dx ; ... les bx,lx1 ; delta x per y add bx,cx mov ax,word ptr es:0[bx] ; here it is! mov dx,word ptr es:2[bx] ; ... add word ptr a,ax ; save it for later adc word ptr a+2,dx ; ... pop es ; restore the segment mov ax,word ptr creal ; initialize x == creal mov dx,word ptr creal+2 ; ... mov word ptr x,ax ; ... mov word ptr x+2,dx ; ... mov ax,word ptr cimag ; initialize y == cimag mov dx,word ptr cimag+2 ; ... mov word ptr y,ax ; ... mov word ptr y+2,dx ; ... mov ax,maxit ; setup k = maxit inc ax ; (+ 1) mov k,ax ; (decrementing to 0 is faster) cmp fractype,1 ; julia or mandelbrot set? je short dojulia ; julia set - go there ; (Tim wants this code changed so that, for the Mandelbrot, ; Z(1) = (x + iy) + (a + ib). Affects only "fudged" Mandelbrots. ; (for the "normal" case, a = b = 0, and this works, too) ; cmp word ptr x,0 ; Mandelbrot shortcut: ; jne short doeither ; if creal = cimag = 0, ; cmp word ptr x+2,0 ; the first iteration can be emulated. ; jne short doeither ; ... ; cmp word ptr y,0 ; ... ; jne short doeither ; ... ; cmp word ptr y+2,0 ; ... ; jne short doeither ; ... ; dec k ; we know the first iteration passed ; mov dx,word ptr a+2 ; copy x = a ; mov ax,word ptr a ; ... ; mov word ptr x+2,dx ; ... ; mov word ptr x,ax ; ... ; mov dx,word ptr b+2 ; copy y = b ; mov ax,word ptr b ; ... ; mov word ptr y+2,dx ; ... ; mov word ptr y,ax ; ... dec k ; we know the first iteration passed mov dx,word ptr a+2 ; add x += a mov ax,word ptr a ; ... add word ptr x,ax ; ... adc word ptr x+2,dx ; ... mov dx,word ptr b+2 ; add y += b mov ax,word ptr b ; ... add word ptr y,ax ; ... adc word ptr y+2,dx ; ... jmp short doeither ; branch around the julia switch dojulia: ; Julia Set initialization ; "fudge" Mandelbrot start-up values mov ax,word ptr x ; switch x with a mov dx,word ptr x+2 ; ... mov bx,word ptr a ; ... mov cx,word ptr a+2 ; ... mov word ptr x,bx ; ... mov word ptr x+2,cx ; ... mov word ptr a,ax ; ... mov word ptr a+2,dx ; ... mov ax,word ptr y ; switch y with b mov dx,word ptr y+2 ; ... mov bx,word ptr b ; ... mov cx,word ptr b+2 ; ... mov word ptr y,bx ; ... mov word ptr y+2,cx ; ... mov word ptr b,ax ; ... mov word ptr b+2,dx ; ... doeither: ; common Mandelbrot, Julia set code cmp numpasses,0 ; multiple-pass mode? jz short singlepass ; nope. proceed. cmp passnum,2 ; second pass? jne short singlepass ; nope. proceed test row,1 ; odd dot? jnz short singlepass ; yup. proceed. test col,1 ; odd dot? jnz short singlepass ; yup. proceed. jmp loopchecks ; nope. skip it. singlepass: mov period,0 ; claim periodicity of 1 mov savedand,1 ; initial periodicity check mov savedincr,1 ; flag for incrementing periodicity mov word ptr savedx+2,0ffffh; impossible value of "old" x mov word ptr savedy+2,0ffffh; impossible value of "old" y mov orbit_ptr,0 ; clear orbits dec kbdcount ; decrement the keyboard counter jns short nokey ; skip keyboard test if still positive mov kbdcount,10 ; stuff in a low kbd count cmp show_orbit,0 ; are we showing orbits? jne quickkbd ; yup. leave it that way. mov kbdcount,5000 ; else, stuff an appropriate count val cmp cpu,386 ; ("appropriate" to the CPU) je short quickkbd ; ... cmp word ptr delmin+2,1 ; is 16-bit math good enough? ja quickkbd ; yes. test less often mov kbdcount,500 ; no. test more often quickkbd: call far ptr keypressed ; has a key been pressed? cmp ax,0 ; ... je nokey ; nope. proceed cmp ax,'o' ; orbit toggle hit? je orbitkey ; yup. show orbits cmp ax,'O' ; orbit toggle hit? jne keyhit ; nope. normal key. orbitkey: call far ptr getakey ; read the key for real mov ax,1 ; reset orbittoggle = 1 - orbittoggle sub ax,show_orbit ; ... mov show_orbit,ax ; ... mov kbdcount,10 ; adjust the keyboard jmp short nokey ; pretend no key was hit keyhit: mov kbdflag,-1 ; yup. reset kbd-hit flag: yes. jmp wedone ; so, bail out! nokey: cmp show_orbit,0 ; is orbiting on? jne no16bitcode ; yup. slow down. cmp cpu,386 ; are we on a 386? je short code386bit ; YAY!! 386-class speed! cmp word ptr delmin+2,1 ; OK, we're desperate. 16 bits OK? ja yes16bitcode ; YAY! 16-bit speed! no16bitcode: call near ptr code32bit ; BOO!! nap time. Full 32 bit math jmp kloopend ; bypass the 386-specific code. yes16bitcode: call near ptr code16bit ; invoke the 16-bit version jmp kloopend ; bypass the 386-specific code. .386 ; 386-specific code starts here code386bit: cmp word ptr delmin+2,3 ; is 16-bit math good enough? jbe code386_32 ; nope, go do 32 bit stuff IFDEF ??version jmp code386_32 ; TASM screws up IMUL EBX,EBX!! ENDIF ; 16 bit on 386, now we are really gonna move movsx esi,word ptr x+2 ; use SI for X movsx edi,word ptr y+2 ; use DI for Y push ebp mov ebp,-1 mov cx,bitshift dec cx shl ebp,cl sub cx,15 kloop386_16: ; cx=bitshift-16, ebp=overflow.mask mov ebx,esi ; compute (x * x) imul ebx,ebx ; ... test ebx,ebp ; say, did we overflow? <V20-compat> jnz short end386_16 ; (oops. We done.) shr ebx,cl ; get result down to 16 bits mov edx,edi ; compute (y * y) imul edx,edx ; ... test edx,ebp ; say, did we overflow? <V20-compat> jnz short end386_16 ; (oops. We done.) shr edx,cl ; get result down to 16 bits mov ax,bx ; compute (x*x - y*y) / fudge sub bx,dx ; for the next iteration add ax,dx ; compute (x*x + y*y) / fudge mov word ptr temp+6,ax ; save last iteration value here cmp ax,word ptr lm+2 ; while (xx+yy < lm) jae short end386_16 ; ... imul edi,esi ; compute (y * x) shl edi,1 ; ( * 2 / fudge) sar edi,cl add di,word ptr b+2 ; (2*y*x) / fudge + b movsx edi,di ; save as y add bx,word ptr a+2 ; (from above) (x*x - y*y)/fudge + a movsx esi,bx ; save as x mov ax,oldcolor ; recall the old color cmp ax,k ; check it against this iter jae short chkpd386_16 ; yup. do periodicity check. nonmax386_16: dec k ; while (k < maxit) jnz short kloop386_16 ; try, try again end386_16: pop ebp jmp kloopend ; we done chkpd386_16: mov ax,k ; set up to test for save-time test ax,savedand ; save on 0, check on anything else jz short chksv386_16 ; time to save a new "old" value mov ax,si ; load up x xor ax,word ptr savedx+2 ; does X match? test ax,word ptr savedmask+2 ; truncate to appropriate precision jne short nonmax386_16 ; nope. forget it. mov ax,di ; now test y xor ax,word ptr savedy+2 ; does Y match? test ax,word ptr savedmask+2 ; truncate to appropriate precision jne short nonmax386_16 ; nope. forget it. mov period,1 ; note that we have found periodicity mov k,0 ; pretend maxit reached jmp short end386_16 chksv386_16: mov word ptr savedx+2,si ; save x mov word ptr savedy+2,di ; save y dec savedincr ; time to change the periodicity? jnz short nonmax386_16 ; nope. shl savedand,1 ; well then, let's try this one! inc savedand ; (2**n -1) mov savedincr,4 ; and reset the increment flag jmp short nonmax386_16 ; 32bit on 386: code386_32: mov esi,x ; use ESI for X mov edi,y ; use EDI for Y ; This is the main processing loop. Here, every T-state counts... cmp bitshift,29 ; only pathalogical concern for speed jne kloop24 ; causes us to use two algorithms here kloop: ; for (k = 0; k <= maxit; k++) mov eax,esi ; compute (x * x) imul esi ; ... shrd eax,edx,FUDGEFACTOR ; ( / fudge) shr edx,FUDGEFACTOR-1 ; (complete 64-bit shift and check jne short kloopend1 ; bail out if too high mov ebx,eax ; save this for below mov eax,edi ; compute (y * y) imul edi ; ... shrd eax,edx,FUDGEFACTOR ; ( / fudge) shr edx,FUDGEFACTOR-1 ; (complete 64-bit shift and check jne short kloopend1 ; bail out if too high mov ecx,ebx ; compute (x*x - y*y) / fudge sub ebx,eax ; for the next iteration add ecx,eax ; compute (x*x + y*y) / fudge cmp ecx,lm ; while (lr < lm) jae short kloopend1 ; ... mov eax,edi ; compute (y * x) imul esi ; ... shrd eax,edx,FUDGEFACTOR-1 ; ( * 2 / fudge) add eax,b ; (above) + b mov edi,eax ; save this as y ; (from the earlier code) ; compute (x*x - y*y) / fudge add ebx,a ; + a mov esi,ebx ; save this as x mov ax,oldcolor ; recall the old color cmp ax,k ; check it against this iter jge short chkperiod1 nonmax1: dec k ; while (k < maxit) (dec to 0 is faster) jnz short kloop ; while (k < maxit) ... kloopend1: jmp kloopend32 ; we done. chkperiod1: mov eax,esi xor eax,savedx test eax,savedmask jnz short chksave1 mov eax,edi xor eax,savedy test eax,savedmask jnz short chksave1 mov period,1 ; note that we have found periodicity mov k,0 ; pretend maxit reached jmp short kloopend1 chksave1: mov ax,k test ax,savedand jne short nonmax1 mov savedx,esi mov savedy,edi dec savedincr ; time to change the periodicity? jnz short nonmax1 ; nope. shl savedand,1 ; well then, let's try this one! inc savedand ; (2**n -1) mov savedincr,4 ; and reset the increment flag jmp short nonmax1 kloop24: ; for (k = 0; k <= maxit; k++) mov eax,esi ; compute (x * x) imul esi ; ... shrd eax,edx,FUDGEFACTOR2 ; ( / fudge) shr edx,FUDGEFACTOR2-1 ; (complete 64-bit shift and check cmp edx,0 ; for any overflow/sign reversals) jne short kloopend32 ; bail out if too high mov ebx,eax ; save this for below mov eax,edi ; compute (y * y) imul edi ; ... shrd eax,edx,FUDGEFACTOR2 ; ( / fudge) shr edx,FUDGEFACTOR2-1 ; (complete 64-bit shift and check cmp edx,0 ; for any overflow/sign reversals) jne short kloopend32 ; bail out if too high mov ecx,ebx ; compute (x*x - y*y) / fudge sub ebx,eax ; for the next iteration add ecx,eax ; compute (x*x + y*y) / fudge mov dword ptr temp+4,ecx ; save the last iteration value here jo short kloopend32 ; bail out if too high js short kloopend32 ; ... cmp ecx,lm ; while (lr < lm) jae short kloopend32 ; ... mov eax,edi ; compute (y * x) imul esi ; ... shrd eax,edx,FUDGEFACTOR2-1 ; ( * 2 / fudge) add eax,b ; (above) + b mov edi,eax ; save this as y ; (from the earlier code) ; compute (x*x - y*y) / fudge add ebx,a ; + a mov esi,ebx ; save this as x mov ax,oldcolor ; recall the old color cmp ax,k ; check it against this iter jb short nonmax241 ; nope. bypass periodicity check. mov x,esi ; save x and y mov y,edi ; for the periodicity check call checkperiod ; check for periodicity nonmax241: dec k ; while (k < maxit) (dec to 0 is faster) jnz short kloop24 ; while (k < maxit) ... jmp kloopend32 ; we done. kloopend32: .8086 ; 386-specific code ends here kloopend: cmp orbit_ptr,0 ; any orbits to clear? je noorbit2 ; nope. push es ; save es call far ptr scrub_orbit ; clear out any old orbits pop es ; restore es noorbit2: mov ax,k ; set old color sub ax,10 ; minus 10, for safety mov oldcolor,ax ; and save it as the "old" color mov ax,maxit ; compute color sub ax,k ; (first, re-compute "k") sub kbdcount,ax ; adjust the keyboard count cmp ax,1 ; convert any "outlier" region jge short coloradjust1 ; (where abs(x) > 2 or abs(y) > 2) mov ax,1 ; to look like we ran through coloradjust1: ; at least one loop. cmp ax,maxit ; did we max out on iterations? jne short coloradjust2 ; nope. mov oldcolor,ax ; set "oldcolor" to maximum add oldcolor,10 ; plus a few cmp inside,0 ; is "inside" >= 0? jl coloradjust2 ; nope. leave it at "maxit" mov ax,inside ; reset max-out color to default cmp debugflag,98 ; show periodicity matches? jne coloradjust2 ; nope. mov al,period ; reset color to periodicity flag coloradjust2: ; cmp potflag,0 ; continuous potential algorithm? je coloradjust3 ; nope. proceed. push es ; prepare to call intpotential push ax ; parameter #2 == the color mov ax,word ptr temp+6 ; parameter #1 == the overflow value push ax ; ... mov ax,word ptr temp+4 ; ... push ax ; ... call far ptr intpotential ; convert the color to potential pop es ; restore the stack and registers pop es ; ... pop es ; ... pop es ; ... coloradjust3: ; cmp LogFlag,0 ; are log palettes set? je coloradjust4 ; nope. don't use log palettes. push es ; save some registers push si ; ... les si,LogTable ; get the address of the Log Table add si,ax ; find the offset of the color mov al,es:0[si] ; replace the color value mov ah,0 ; ... pop si ; restore the registers pop es ; ... coloradjust4: ; cmp ax,colors ; fast skip, and avoid inside/outside=0 jl coloradjust6 ; no need to adjust cmp colors,16 ; >= 16 colors? jge coloradjust5 ; branch if so and ax,andcolor ; just mask the color jmp short coloradjust6 ; go store it coloradjust5: ; >=16 colors, skip using color zero sub dx,dx ; setup for divide dec ax ; color - 1 div andcolor ; divide by colors-1 mov ax,dx ; color-1 modulus colors-1 inc ax ; add back what we took off at start coloradjust6: mov color,al ; color result mov cx,col ; set up the registers mov dx,row ; for the write routine call near ptr displaydot ; display the dot, do symmetry if any cmp calcmode,0 ; called for just 1 pixel? je passcheck0 ; nope, go check 1 vs 2 pass stuff mov al,color ; setup return of color xor ah,ah ; ... mov kbdflag,ax ; ... jmp wedone ; finished passcheck0: cmp passnum,2 ; final pass? je loopchecks ; yup, no extra dots to write passcheck1: mov cx,col ; set up the registers test cx,1 ; doing odd col at start of pass 1? jnz passcheck2 ; yup, skip the dot to the right cmp cx,ixstop ; at the right edge? jge passcheck2 ; yup, skip the dot to the right mov dx,row ; for the write routine inc cx ; (but for the next x-dot) call near ptr displaydot ; display the dot, do symmetry if any passcheck2: mov cx,col ; set up the registers mov dx,row ; for the write routine test dx,1 ; doing odd row at start of pass 1? jnz passcheck3 ; yup, skip the row below cmp dx,iystop ; at the bottom? jge passcheck3 ; yup, skip the row below inc dx ; (but for the next y-dot) call near ptr displaydot ; display the dot, do symmetry if any mov cx,col ; set up the registers test cx,1 ; doing odd col at start of pass 1? jnz loopchecks ; yup, skip the dot to the right cmp cx,ixstop ; at the right edge? jge loopchecks ; yup, skip the dot to the right mov dx,row ; for the write routine inc cx ; (but for the next x-dot) inc dx ; (and the next y-dot) call near ptr displaydot ; display the dot, do symmetry if any passcheck3: test col,1 ; doing odd col at start of pass 1? jnz loopchecks ; yup, incr col just once inc col ; note extra dots have been written loopchecks: inc col ; check for end of xloop mov ax,col ; ... cmp ax,ixstop ; ... ja loopcheck1 ; we done. jmp xloop ; more to go loopcheck1: cmp passnum,2 ; last pass? je short lastpass ; yup. proceed. test row,1 ; doing odd row at start of pass 1? jnz short lastpass inc row ; adjust y-value lastpass: inc row ; check for end of yloop mov ax,row ; ... cmp ax,iystop ; ... ja wedone ; we done. jmp yloop ; nope. more to go wedone: ; restore everything and return. call asmvideocleanup ; perform any video cleanup required pop es ; restore the original ES value pop si pop di mov ax,kbdflag ; return the keyboard-interrupt flag ret ; and return. calcmandasm endp ; ******************** Function displaydot ****************************** ; ; Display dot, checking for out of bounds and doing symmetry. ; Call with cx=col, dx=row. ; displaydot proc near push cx ; save these for symmetry plot push dx ; ... mov al,color ; color to use call asmdotwrite ; invoke the appropriate write-a-dot pop dx ; restore row/col pop cx ; ... cmp symmetry,0 ; does symmetry apply? jne dspret ; nope. done. sub dx,yystart ; yystop-(row-yystart) neg dx ; ... add dx,yystop ; ... cmp dx,iystop ; if not > iystop jle dspret ; this row is the axis, skip it cmp dx,ydots ; out of bounds? jge dspret ; yup, skip it cmp fractype,0 ; Mandelbrot set? je dspsym ; yup. Skip Julia symmetry sub cx,xxstart ; convert to xxstop-(col-xxstart) neg cx ; ... add cx,xxstop ; ... cmp cx,xdots ; out of bounds? (subtle possibility) jge dspret ; yup, skip it dspsym: mov al,color ; color to use call asmdotwrite ; invoke the appropriate write-a-dot dspret: ret displaydot endp ; ******************** Function code16bit() ***************************** ; ; Performs "short-cut" 16-bit math where we can get away with it. ; code16bit proc near mov si,word ptr x+2 ; use SI for X mov di,word ptr y+2 ; use DI for Y start16bit: mov ax,si ; compute (x * x) imul si ; ... cmp dx,0 ; say, did we overflow? <V20-compat> jl end16bit ; (oops. We done.) mov cx,32 ; ( / fudge) sub cx,bitshift ; ... loop16bit1: shl ax,1 ; ... rcl dx,1 ; ... jo end16bit ; (oops. overflow) loop loop16bit1 ; ... mov bx,dx ; save this for a tad mov ax,di ; compute (y * y) imul di ; ... cmp dx,0 ; say, did we overflow? <V20-compat> jl end16bit ; (oops. We done.) mov cx,32 ; ( / fudge) sub cx,bitshift ; ... loop16bit2: shl ax,1 ; ... rcl dx,1 ; ... jo end16bit ; (oops. overflow) loop loop16bit2 ; ... mov cx,bx ; compute (x*x - y*y) / fudge sub bx,dx ; for the next iteration add cx,dx ; compute (x*x + y*y) / fudge mov word ptr temp+6,cx ; save last iteration value here jo end16bit ; bail out if too high js end16bit ; ... cmp cx,word ptr lm+2 ; while (xx+yy < lm) jae end16bit ; ... mov ax,di ; compute (y * x) imul si ; ... mov cx,33 ; ( * 2 / fudge) sub cx,bitshift ; ... loop16bit3: shl ax,1 ; ... rcl dx,1 ; ... loop loop16bit3 ; ... add dx,word ptr b+2 ; (2*y*x) / fudge + b mov di,dx ; save as y add bx,word ptr a+2 ; (from above) (x*x - y*y)/fudge + a mov si,bx ; save as x mov ax,oldcolor ; recall the old color cmp ax,k ; check it against this iter jb short nonmax3 ; nope. bypass periodicity check. mov word ptr x+2,si ; save x for periodicity check mov word ptr y+2,di ; save y for periodicity check call checkperiod ; check for periodicity nonmax3: dec k ; while (k < maxit) jz end16bit ; we done. jmp start16bit ; try, try again. end16bit: ; we done. ret code16bit endp ; ******************** Function code32bit() ***************************** ; ; Perform the 32-bit logic required using 16-bit logic ; mult32bit performs 32bit x 32bit signed multiplies, with ; (temporary) 64-bit results, and the appropriate right-shift ; ( >> FUDGEFACTOR) before returning. That's why it is so long. ; arguments in SI:BX and DI:CX, results in DX:AX mult32bit proc near mov ax,0 mov temp+4,ax ; first, clear out the (temporary) mov temp+6,ax ; result mov sign,0 ; clear out the sign flag cmp si,0 ; is SI:BX negative? jge mults1 ; nope not sign ; yup. flip signs not bx ; ... not si ; ... stc ; ... adc bx,ax ; ... adc si,ax ; ... mults1: cmp di,0 ; is DI:CX negative? jge mults2 ; nope not sign ; yup. flip signs not cx ; ... not di ; ... stc ; ... adc cx,ax ; ... adc di,ax ; ... mults2: mov ax,bx ; perform BX x CX mul cx ; ... ; mov temp,ax ; results in lowest 32 bits mov temp+2,dx ; ... mov ax,bx ; perform BX x DI mul di ; ... add temp+2,ax ; results in middle 32 bits adc temp+4,dx ; ... jnc mults3 ; carry bit set? inc word ptr temp+6 ; yup. overflow mults3: mov ax,si ; perform SI * CX mul cx ; ... add temp+2,ax ; results in middle 32 bits adc temp+4,dx ; ... jnc mults4 ; carry bit set? inc word ptr temp+6 ; yup. overflow mults4: mov ax,si ; perform SI * DI mul di ; ... add temp+4,ax ; results in highest 32 bits adc temp+6,dx ; ... mov ax,temp+4 ; set up to fake SHR FUDGEFACTOR mov dx,temp+6 ; by SHL 3 and using high-order dword mov si,temp+2 ; ... mov cx,32 ; ( / fudge) sub cx,bitshift ; ... multl1: shl si,1 ; shift one bit rcl ax,1 ; ... rcl dx,1 ; ... jc multovfl ; (oops. overflow) loop multl1 ; shift another bit, if need be cmp dx,0 ; overflow on "negative" result jl multovfl ; ... cmp sign,0 ; should we negate the result? je mults5 ; nope. not ax ; yup. flip signs. not dx ; ... mov bx,0 ; ... stc ; ... adc ax,bx ; ... adc dx,bx ; ... mults5: multnoovfl: ; normal exit clc ; no carry ret ; we done. multovfl: ; overflow exit stc ; set carry ret ; we done. mult32bit endp code32bit proc near start32bit: mov bx,word ptr x ; set up to multiply x * x mov si,word ptr x+2 ; ... mov cx,bx ; ... mov di,si ; ... call mult32bit ; do it. jnc ok32bit1 ; no overflow. continue. jmp end32bit ; overflow. we done. ok32bit1: mov word ptr xx,ax ; save this for a tad. mov word ptr xx+2,dx ; ... mov bx,word ptr y ; set up to multiply y * y mov si,word ptr y+2 ; ... mov cx,bx ; ... mov di,si ; ... call mult32bit ; do it. jnc ok32bit2 ; no overflow. continue. jmp end32bit ; overflow. we done. ok32bit2: mov word ptr yy,ax ; save this for a tad. mov word ptr yy+2,dx ; ... mov ax,word ptr xx ; calculate (x*x + y*y) mov dx,word ptr xx+2 ; ... add ax,word ptr yy ; ... adc dx,word ptr yy+2 ; ... jo short end32bit ; bail out if too high js short end32bit ; ... cmp dx,word ptr lm+2 ; while (lr < lm) jae end32bit ; ... mov ax,word ptr xx ; calculate (x*x - y*y) mov dx,word ptr xx+2 ; ... sub ax,word ptr yy ; ... sbb dx,word ptr yy+2 ; ... mov word ptr xxmyy,ax ; ... mov word ptr xxmyy+2,dx ; ... mov bx,word ptr x ; set up to multiply x * y mov si,word ptr x+2 ; ... mov cx,word ptr y ; ... mov di,word ptr y+2 ; ... call mult32bit ; do it. shl ax,1 ; multiply by 2 rcl dx,1 ; ... add ax,word ptr b ; add b adc dx,word ptr b+2 ; ... mov word ptr y,ax ; save the result as y mov word ptr y+2,dx ; ... mov ax,word ptr xxmyy ; remember (x*x - y*y) mov dx,word ptr xxmyy+2 ; ... add ax,word ptr a ; add a adc dx,word ptr a+2 ; .. mov word ptr x,ax ; save the result as x mov word ptr x+2,dx ; ... mov ax,oldcolor ; recall the old color cmp ax,k ; check it against this iter jb short nonmax2 ; nope. bypass periodicity check. call checkperiod ; check for periodicity nonmax2: call checkorbit ; check for orbiting dec k ; while (k < maxit) jz end32bit ; we done. jmp start32bit ; try, try again. end32bit: ; we done. mov word ptr temp+6,dx ; save last iteration value here ret ; return. code32bit endp ; The following routine checks for periodic loops (a known ; method of decay inside "Mandelbrot Lake", and an easy way to ; bail out of "lake" points quickly). For speed, only the ; high-order sixteen bits of X and Y are checked for periodicity. ; For accuracy, this routine is only fired up if the previous pixel ; was in the lake (which means that the FIRST "wet" pixel was ; detected by the dull-normal maximum iteration process). checkperiod proc near ; periodicity check mov ax,k ; set up to test for save-time test ax,savedand ; save on 0, check on anything else jz checksave ; time to save a new "old" value mov dx,word ptr x+2 ; load up x and dx,word ptr savedmask+2 ; truncate to appropriate precision cmp dx,word ptr savedx+2 ; does X match? jne checkdone ; nope. forget it. mov ax,word ptr x ; load up x and ax,word ptr savedmask ; truncate to appropriate precision cmp ax,word ptr savedx ; does X match? jne checkdone ; nope. forget it. mov dx,word ptr y+2 ; now test y and dx,word ptr savedmask+2 ; truncate to appropriate precision cmp dx,word ptr savedy+2 ; does Y match? jne checkdone ; nope. forget it. mov ax,word ptr y ; load up y and ax,word ptr savedmask ; truncate to appropriate precision cmp ax,word ptr savedy ; does Y match? jne checkdone ; nope. forget it. mov period,1 ; note that we have found periodicity mov k,1 ; pretend maxit reached checksave: mov dx,word ptr x+2 ; load up x and dx,word ptr savedmask+2 ; truncate to appropriate precision mov word ptr savedx+2,dx ; and save it mov ax,word ptr x ; load up x and ax,word ptr savedmask ; truncate to appropriate precision mov word ptr savedx,ax ; and save it mov dx,word ptr y+2 ; load up y and dx,word ptr savedmask+2 ; truncate to appropriate precision mov word ptr savedy+2,dx ; and save it mov ax,word ptr y ; load up y and ax,word ptr savedmask ; truncate to appropriate precision mov word ptr savedy,ax ; and save it dec savedincr ; time to change the periodicity? jnz checkdone ; nope. shl savedand,1 ; well then, let's try this one! inc savedand ; (2**n -1) mov savedincr,4 ; and reset the increment flag checkdone: ret ; we done. checkperiod endp checkorbit proc near cmp show_orbit,0 ; was orbiting on? je nonorbit1 ; nope. push es ; save ES mov ax,-1 ; push -1 onto the stack push ax ; ... mov ax,word ptr y ; save y mov dx,word ptr y+2 ; ... push dx ; ... push ax ; ... mov ax,word ptr x ; save x mov dx,word ptr x+2 ; ... push dx ; ... push ax ; ... call far ptr iplot_orbit ; display the orbit pop ax ; clear out the parameters pop ax ; ... pop ax ; clear out the parameters pop ax ; ... pop ax ; clear out the parameters pop es ; restore ES nonorbit1: ret checkorbit endp calcmand_TEXT ends end